/*
 * @Description: In User Settings Edit
 * @Author: xiaoying
 * @Date: 2019-09-03 16:44:08
 * @LastEditTime: 2019-09-23 10:21:17
 * @LastEditors: mayuanye
 */
import { NativeModules } from 'react-native';
import ThemeInfo from './ThemeInfo.js';
import RangeThemeInfo from './RangeThemeInfo.js';
import VectorTheme from './VectorTheme.js';
let RT = NativeModules.JSRangeTheme;

/**
 * @class RangeTheme
 * @description 范围专题图
 */
export default class RangeTheme extends VectorTheme {
  constructor() {
    super();
    Object.defineProperty(this, '_MGRangeThemeId', {
      get: function() {
        return this._MGVectorThemeId;
      },
      set: function(_MGRangeThemeId) {
        this._MGVectorThemeId = _MGRangeThemeId;
      },
    });
  }

  /**
   * 创建一个新的RangeTheme对象
   *
   * @memberof RangeTheme
   * @returns {Promise<RangeTheme>}
   */
  async createObj() {
    try {
      var { RangeThemeId } = await RT.createObj();
      var rangeTheme = new RangeTheme();
      rangeTheme._MGRangeThemeId = RangeThemeId;
      return rangeTheme;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取缺省专题绘制信息
   *
   * @memberof RangeTheme
   * @returns {Promise<ThemeInfo>} 缺省专题绘制信息
   */
  async getDefaultInfo() {
    try {
      var { ThemeInfoId } = await RT.getDefaultInfo(this._MGRangeThemeId);
      var themeInfo = null;
      if (ThemeInfoId != null) {
        themeInfo = new ThemeInfo();
        themeInfo._MGThemeInfoId = ThemeInfoId;
      }

      return themeInfo;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置缺省专题绘制信息
   *
   * @memberof RangeTheme
   * @param {Object} themeInfo 专题绘制信息
   * @returns {Promise<Void>}
   */
  async setDefaultInfo(themeInfo) {
    try {
      await RT.setDefaultInfo(this._MGRangeThemeId, themeInfo._MGThemeInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取字段表达式
   *
   * @memberof RangeTheme
   * @returns {String}
   */
  async getExpression() {
    try {
      let expression = await RT.getExpression(this._MGRangeThemeId);
      return expression;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置字段表达式
   *
   * @memberof RangeTheme
   * @param {String} expression 字段表达式
   * @returns {Promise<Void>}
   */
  async setExpression(expression) {
    try {
      await RT.setExpression(this._MGRangeThemeId, expression);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取项数目
   *
   * @memberof RangeTheme
   * @returns {int}
   */
  async getCount() {
    try {
      let count = await RT.getCount(this._MGRangeThemeId);
      return count;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取专题图类型
   *
   * @memberof RangeTheme
   * @returns {int} 返回专题图类型，例：AllOtherDataItemInfoSource.DefaultThemeInfo
   */
  async getAllOtherDataItemInfoSource() {
    try {
      let allOtherDataItemInfoSource = await RT.getAllOtherDataItemInfoSource(
        this._MGRangeThemeId
      );
      return allOtherDataItemInfoSource;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置专题图类型
   *
   * @memberof RangeTheme
   * @param {int} allOtherDataItemInfoSource 专题图类型 例：AllOtherDataItemInfoSource.DefaultThemeInfo
   * @returns {Promise<Void>}
   */
  async setAllOtherDataItemInfoSource(allOtherDataItemInfoSource) {
    try {
      await RT.setAllOtherDataItemInfoSource(
        this._MGRangeThemeId,
        allOtherDataItemInfoSource
      );
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 添加项
   *
   * @memberof RangeTheme
   * @param {Object} rangeThemeInfo 范围专题图项信息
   * @returns {int}                 成功返回项索引
   */
  async append(rangeThemeInfo) {
    try {
      let index = await RT.append(
        this._MGRangeThemeId,
        rangeThemeInfo._MGRangeThemeInfoId
      );
      return index;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 删除项（删除之后的语义是图元用未分类字段的颜色）
   *
   * @memberof RangeTheme
   * @param {int} index  范围专题图项索引
   * @returns {boolean}  true-成功 ；false-失败
   */
  async remove(index) {
    try {
      let result = await RT.remove(this._MGRangeThemeId, index);
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 寻找值为value的项索引
   *
   * @memberof RangeTheme
   * @param {String} value  属性值
   * @returns {int}         成功返回包含此值的项索引
   */
  async indexOf(value) {
    try {
      let index = await RT.indexOf(this._MGRangeThemeId, value);
      return index;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 清空所有的项
   *
   * @memberof RangeTheme
   * @returns {boolean}   true-成功 ；false-失败
   */
  async clear() {
    try {
      let result = await RT.clear(this._MGRangeThemeId);
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置项信息
   *
   * @memberof RangeTheme
   * @param {Number} index   范围专题图项索引（int类型的Number）
   * @param {Object) rangeThemeInfo   范围专题图项信息
   * @returns {boolean}   true-成功 ；false-失败
   */
  async setItem(index, rangeThemeInfo) {
    try {
      let result = await RT.setItem(
        this._MGRangeThemeId,
        index,
        rangeThemeInfo._MGRangeThemeInfoId
      );
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取项信息
   *
   * @memberof RangeTheme
   * @param {Number} index                范围专题图项索引（int类型的Number）
   * @returns {Promise<RangeThemeInfo>}   成功返回项的信息
   */
  async getItem(index) {
    try {
      var { RangeThemeInfoId } = await RT.getItem(this._MGRangeThemeId, index);
      var rangeThemeInfo = null;
      if (RangeThemeInfoId != null) {
        rangeThemeInfo = new RangeThemeInfo();
        rangeThemeInfo._MGRangeThemeInfoId = RangeThemeInfoId;
      }

      return rangeThemeInfo;
    } catch (e) {
      console.error(e);
    }
  }

  // /**
  //  * 合并项,从index开始count个项合并
  //  *
  //  * @memberof RangeTheme
  //  * @param {int} index        合并项开始位置
  //  * @param {int} count        合并项的数目
  //  * @param {Object} geomInfo  合并后的图形信息
  //  * @param {String} caption   合并后的标题
  //  * @returns {boolean}        true-成功 ； false-失败
  //  */
  // async merge(index, count, geomInfo, caption){
  //     try {
  //         let result = await RT.merge(this._MGRangeThemeId, index, count, geomInfo._MGGeomInfoId, caption);
  //         return result;
  //     } catch (e) {
  //         console.error(e);
  //     }
  // }

  // /**
  //  * 拆分项（拆分为2个项）
  //  *
  //  * @memberof RangeTheme
  //  * @param {int} index          拆分项开始位置
  //  * @param {double} splitValue  拆分值
  //  * @param {Object} geomInfo1   拆分后的图形信息1
  //  * @param {String} caption1    拆分后的标题1
  //  * @param {Object} geomInfo2   拆分后的图形信息2
  //  * @param {String} caption2    拆分后的标题2
  //  * @returns {boolean}          true-成功 ； false-失败
  //  */
  // async split(index, splitValue, geomInfo1, caption1, geomInfo2, caption2){
  //     try {
  //         let result = await RT.split(this._MGRangeThemeId, index, splitValue, geomInfo1._MGGeomInfoId, caption1, geomInfo2._MGGeomInfoId, caption2);
  //         return result;

  //     } catch (e) {
  //         console.error(e);
  //     }
  // }
}
